package com.estate.common.config;


import org.springframework.stereotype.Component;

import java.util.Random;

@Component
public class SnowflakeIdWorker {
  /** 开始时间截 (建议用服务第一次上线的时间，到毫秒级的时间戳) */
  private final long twepoch = 1656518400000L;
  /** 机器id所占的位数 */
  private final long workerIdBits = 4L;

  /** 支持的最大机器id，结果是1023 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
  private final long maxWorkerId = -1L ^ (-1L << workerIdBits);

  /** 序列在id中占的位数 */
  private final long sequenceBits = 8L;

  /** 机器ID向左移12位 */
  private final long workerIdShift = sequenceBits;

  /** 时间截向左移22位(10+12) */
  private final long timestampLeftShift = sequenceBits + workerIdBits;

  /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
   * <<为左移，每左移动1位，则扩大1倍
   * */
  private final long sequenceMask = -1L ^ (-1L << sequenceBits);

  /** 工作机器ID(0~1024) */
  private long workerId = 10L;

  /** 毫秒内序列(0~4095) */
  private long sequence = 0L;

  /** 上次生成ID的时间截 */
  private long lastTimestamp = -1L;

  // ==============================Methods==========================================
  /**
   * 获得下一个ID (该方法是线程安全的)
   * @return SnowflakeId
   */
  public synchronized long nextId() {

    if (workerId > maxWorkerId || workerId < 0) {
      throw new IllegalArgumentException(String.format("workerId can't be greater than %d or less than 0", maxWorkerId));
    }
    long timestamp = timeGen();
    //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
    if (timestamp < lastTimestamp) {
      throw new RuntimeException(
              String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
    }

    //如果是同一时间生成的，则进行毫秒内序列
    if (lastTimestamp == timestamp) {
      //如果毫秒相同，则从0递增生成序列号
      sequence = (sequence + 1) & sequenceMask;
      //毫秒内序列溢出
      if (sequence == 0) {
        //阻塞到下一个毫秒,获得新的时间戳
        timestamp = tilNextMillis(lastTimestamp);
      }
    }
    //时间戳改变，毫秒内序列重置
    else {
      sequence = new Random().nextInt(9);
    }

    //上次生成ID的时间截
    lastTimestamp = timestamp;

    //移位并通过或运算拼到一起组成64位的ID
    return ((timestamp - twepoch) << timestampLeftShift) //
            | (workerId << workerIdShift) //
            | sequence;
  }

  /**
   * 阻塞到下一个毫秒，直到获得新的时间戳
   * @param lastTimestamp 上次生成ID的时间截
   * @return 当前时间戳
   */
  protected long tilNextMillis(long lastTimestamp) {
    long timestamp = timeGen();
    while (timestamp <= lastTimestamp) {
      timestamp = timeGen();
    }
    return timestamp;
  }

  /**
   * 返回以毫秒为单位的当前时间，从1970-01-01 08:00:00算起
   * @return 当前时间(毫秒)
   */
  protected long timeGen() {
    return System.currentTimeMillis();
  }


  private volatile static SnowflakeIdWorker singleton;

  private SnowflakeIdWorker(){}

  public static SnowflakeIdWorker getSingleton() {

    if (singleton == null) {

      synchronized (SnowflakeIdWorker.class) {

        if (singleton == null) {

          singleton = new SnowflakeIdWorker();

        }

      }

    }

    return singleton;

  }

  public static void main(String[] args) {
    for (int i=0; i<10;i++) {
      System.out.println(SnowflakeIdWorker.getSingleton().nextId());
    }
  }

}

